home *** CD-ROM | disk | FTP | other *** search
/ Magnum One / Magnum One (Mid-American Digital) (Disc Manufacturing).iso / d12 / c_toolbx.arc / SWINT.ASM < prev    next >
Encoding:
Assembly Source File  |  1988-03-30  |  4.9 KB  |  132 lines
  1. ;       swint.asm - software interrupt function
  2. ;
  3. ;       structure for register values is
  4. ;               struct regval{ unsigned ax,bx,cx,dx,si,di,ds,es; } ;
  5. ;       the following defines the offsets for use in the asm. functions
  6. ;
  7. regs    struc
  8. reg_ax  dw      0      ; ax value
  9. reg_bx  dw      0      ; bx value
  10. reg_cx  dw      0      ; cx value
  11. reg_dx  dw      0      ; dx value
  12. reg_si  dw      0      ; si value
  13. reg_di  dw      0      ; di value
  14. reg_bp  dw      0      ; bp value
  15. reg_sp  dw      0      ; sp value
  16. reg_ds  dw      0      ; ds value
  17. reg_es  dw      0      ; es value
  18. reg_ss  dw      0      ; ss value
  19. reg_cs  dw      0      ; cs value
  20. regs    ends
  21. ;
  22. ;       start data section
  23.         include begdata.ha
  24.         include enddata.ha
  25. ;
  26. ;       start code section
  27.         include begcode.ha
  28. ;
  29. ;       execute in ROM BIOS s/w int 10H with registers ax-dx set up
  30. ;
  31. ;       typedef struct
  32. ;        {  word16 ax,bx,cx,dx,si,di,sp,bp,ds,es,ss,cs; } REGS ;
  33. ;       REGS    sregs , /* input register values */
  34. ;               dregs ; /* values returned in regs */
  35. ;       int     fun_no ;        /* number of function to execute */
  36. ;
  37. ;       ax_value = vidint(fun_no,&input_regs,&return_regs);
  38. vid_args        struc           ; input arguments
  39.         dw      0               ; saved BP value
  40.         dw      0               ; return address
  41. fun_no  dw      0               ; specific function reqyested (AH value)
  42. vid_sreg dw     0               ; address of input reg. values
  43. vid_dreg dw     0               ; store returned reg. values here
  44. vid_args ends
  45. ;
  46.         public  vidint
  47. vidint:
  48.         push    bp
  49.         mov     bp,sp           ; set our argument pointer
  50.         push    si              ; save current register values
  51.         push    di              ;
  52.         mov     bx,word ptr vid_sreg[bp] ; get input reg. val. addr.
  53.         mov     ax,word ptr reg_ax[bx]   ; place values in registers
  54.         mov     cx,word ptr reg_cx[bx]
  55.         mov     dx,word ptr reg_dx[bx]
  56.         mov     bx,word ptr reg_bx[bx]
  57.         mov     ah,byte ptr fun_no[bp]
  58.         int     16              ; VIEDO I/O ROM BIOS call
  59.         mov     di,word ptr vid_dreg[bp] ; get return reg. area addr.
  60.         mov     word ptr reg_ax[di],ax   ; store register values there
  61.         mov     word ptr reg_bx[di],bx
  62.         mov     word ptr reg_cx[di],cx
  63.         mov     word ptr reg_dx[di],dx
  64.         pop     di              ; restore register values
  65.         pop     si
  66.         pop     bp
  67.         ret
  68. ;
  69. ;
  70. ;       execute an s/w function call with all registers set up
  71. ;
  72. ;       typedef struct
  73. ;        {  word16 ax,bx,cx,dx,si,di,sp,bp,ds,es,ss,cs; } REGS ;
  74. ;       REGS    sregs , /* input register values */
  75. ;               dregs ; /* values returned in regs */
  76. ;       int     status ; /* 8088 status flags returned by the INT call
  77. ;
  78. ;       status = swint(fun_code,&input_regs,&return_regs) ;
  79. swint_args struc                ; input arguments
  80.         dw      0               ; saved BP value
  81.         dw      0               ; return address
  82. int_no  dw      0               ; number of software interrupt to issue
  83. sw_sreg dw      0               ; address of input reg. values
  84. sw_dreg dw      0               ; store returned reg. values here
  85. swint_args ends
  86. ;
  87.         public  swint
  88. swint:
  89.         push    bp
  90.         mov     bp,sp           ; set our arg pointer
  91.         push    ds              ; save current register values
  92.         push    es
  93.         push    si
  94.         push    di
  95.         mov     al,byte ptr int_no[bp] ; insert int, no. into instr.
  96.         mov     cs:byte ptr int_instr[1],al
  97.         mov     bx,word ptr sw_sreg[bp] ; get input reg. values addr.
  98.         mov     ax,word ptr reg_ax[bx]  ; place values in registers
  99.         mov     cx,word ptr reg_cx[bx]
  100.         mov     dx,word ptr reg_dx[bx]
  101.         mov     si,word ptr reg_si[bx]
  102.         mov     di,word ptr reg_di[bx]
  103.         mov     es,word ptr reg_es[bx]
  104.         mov     ds,word ptr reg_ds[bx]
  105.         mov     bx,ss:word ptr reg_bx[bx]
  106. int_instr:
  107.         int     32              ; dummy int. (no. filled in on each use
  108.         mov     bp,word ptr sw_dreg[bp] ; get & dreg structure
  109.         mov     word ptr reg_ax[bp],ax  ; store register values in
  110.         mov     word ptr reg_bx[bp],bx  ; return reg. structure
  111.         mov     word ptr reg_cx[bp],cx
  112.         mov     word ptr reg_dx[bp],dx
  113.         mov     word ptr reg_si[bp],si
  114.         mov     word ptr reg_di[bp],di
  115.         mov     word ptr reg_ds[bp],ds
  116.         mov     word ptr reg_es[bp],es
  117.         pushf                   ; return flags
  118.         pop     ax              ; in ax
  119.         cld                     ; make sure D flag is cleared on return
  120.         pop     di              ; restore registers
  121.         pop     si
  122.         pop     es
  123.         pop     ds
  124.         pop     bp
  125.         ret
  126. ;
  127.         include endcode.ha
  128.         end
  129. ;
  130. ;
  131.  
  132.